#include <iostream>
#include <unistd.h>
#include <pthread.h>

#include <cstdio>
#include <cstring>
#include <errno.h>
using namespace std;

#include<thread>

void fun()
{
    while(1)
    {
        cout << "thread is running" << endl;
        sleep(1);
    }
}

int main()
{
    thread t1(fun);
    thread t2(fun);
    thread t3(fun);
    thread t4(fun);

    while(1)
    {
        cout << "main thread is running" << endl;
        sleep(1);
    }

    t1.join();
    t2.join();
    t3.join();
    t4.join();

    return 0;
}


// void* threadRoutine(void* arg)
// {
//     // 线程分离
//     pthread_detach(pthread_self());
//     printf("thread1 [%p] is running\n", pthread_self());

//     // 线程分离并除零
//     int a = 10;
//     a /= 0;

//     return (void*)10;
// }

// int main()
// {
//     pthread_t tid;
//     pthread_create(&tid, nullptr, threadRoutine, nullptr);

//     printf("main thread [%p] running\n", pthread_self());
//     // 主线程睡3s
//     sleep(3);

//     void* res;
//     // 线程分离但还强制等待
//     int ret = pthread_join(tid, &res);
//     printf("join return val ::%d, strerror ::%s, res ::%d\n", ret, strerror(ret), (long)res);

//     return 0;
// }

// int main()
// {
//     // signal(SIGCHLD, SIG_IGN);

//     pid_t pid = fork();

//     if(pid == 0)
//     {
//         int count = 0;
//         while(1)
//         {
//             cout << "child [ " << getpid() << " ] is running" << endl;
//             sleep(1);

//             ++count;
//             if(count == 5)  break;
//         }

//         exit(1);
//     }

//     sleep(10);
//     // 父进程
//     printf("father process %d is waiting child process %d\n", getpid(), pid);
//     waitpid(pid, nullptr, 0);

//     return 0;
// }

// void* threadRoutine(void* arg)
// {
//     (void)arg;
    
//     pid_t pid = fork();

//     if(pid == 0)
//     {
//         // 子进程
//         int count = 0;
//         while(1)
//         {
//             printf("child process %d is running\n", getpid());
//             printf("===================================\n");
//             sleep(1);
         
//             ++count;
//             if(count == 5) break;
//         }

//         exit(0);
//     }

//     // 父进程
//     printf("father process %d is waiting child process %d\n", getpid(), pid);
//     waitpid(pid, nullptr, 0);
    
//     printf("wait success\n");

//     return nullptr;
// }

// int main()
// {
//     pthread_t tid;
//     pthread_create(&tid, nullptr, threadRoutine, nullptr);

//     while(1)
//     {
//         sleep(1);
//         printf("main thread running\n");
//     }

//     return 0;
// }


// __thread int g_val = 0;

// void* threadRoutine(void* arg)
// {
//     execl("/bin/ls", "ls", nullptr);
// }

// int main()
// {
//     pthread_t tid;
//     pthread_create(&tid, nullptr, threadRoutine, (void*)"thread1");

//     while(1)
//     {
//         printf("main thread -> g_val :: %d, p ::%p\n", g_val, &g_val);
//         sleep(1);
//     }

//     return 0;
// }


// void* threadRoutine(void* arg)
// {
//     pthread_t tid = pthread_self();
//     int count = 0;
//     cout << (char*)arg << " is running, ";
//     printf("id, lu:: %lu , p :: %p\n", tid, tid);

//     sleep(2);

//     return (void*)10;
// }

// int main()
// {
//     pthread_t tid;
//     pthread_create(&tid, nullptr, threadRoutine, (void*)"thread1");
//     sleep(1);
//     printf("thread 1 id, lu:: %lu , p :: %p\n", tid, tid);


//     // 主线程等待从线程
//     cout << "main thread waiting" << endl;


//     void* ret;
//     // 返回值放到ret中
//     pthread_join(tid, &ret);
//                                         // linux下是64位的，这里ret大小为8，所以得用8字节的long或long long来强转
//                                         // 用int报错
//     cout << "threadRoutine's return val ::" << (long)ret << endl;    

//     return 0;
// }


//#include <unordered_map>

// void* threadRoutine(void* arg)
// {
//     int count = 0;
//     cout << (char*)arg << " start to running" << endl;

//     int a = 20;
//     a /= 0;

//     // 返回值
//     //return (void*)10;

//     int* arr = new int[10];
//     for(int i = 0; i < 10; ++i)
//     {
//         arr[i] = i;
//     }
//     return (void*)arr;
// }

// int main()
// {
//     pthread_t tid;
//     pthread_create(&tid, nullptr, threadRoutine, (void*)"thread1");
//     sleep(1);

//     // 主线程等待从线程
//     cout << "main thread waiting" << endl;
//     void* ret;
//     // 返回值放到ret中
//     pthread_join(tid, &ret);
//                                         // linux下是64位的，这里ret大小为8，所以得用8字节的long或long long来强转
//                                         // 用int报错
//     cout << "threadRoutine's return val ::";
//     for(int i = 0; i < 10; ++i)
//     {
//         cout << " " << *((int*)ret + i);
//     }
    
//     cout << endl;
//     delete[] (int*)ret;

//     return 0;
// }

// int x = 100;

// void show(const string &name)
// {
//     cout << name << ", pid: " << getpid() << " " << x << "\n"
//          <<  endl;
// }

// void *threadRun(void *args)
// {
//     const string name = (char *)args;
//     while (true)
//     {
//         show(name);
//         sleep(1);
//     }
// }

// int main()
// {
//     pthread_t tid[5];
//     char name[64];
//     for (int i = 0; i < 5; i++)
//     {
//         snprintf(name, sizeof name, "%s-%d", "thread", i);
//         pthread_create(tid + i, nullptr, threadRun, (void *)name);
//         sleep(1); // 缓解传参的bug
//     }

//     while (true)
//     {
//         cout << "main thread, pid: " << getpid() << endl;
//         sleep(3);
//     }
// }

// #include <iostream>
// using namespace std;

// #include <pthread.h>

// #include <unistd.h>

// // 回调函数的方法
// void* threadRoutine(void* arg)
// {
// 	// thread1 不断运行
//     while(1)
//     {
//         cout << (char*)arg << " is running, pid:: " << getpid() << "\n" << endl;
//         sleep(1);
//     }
// }

// int main()
// {
//     // 创建的线程个数
//     int n = 5;

//     // 线程的id
//     pthread_t tid[n];
//     char* name[n];
//     for(int i = 0; i < n; ++i)
//     {
//         name[i] = (char*)malloc(10);
//         snprintf(name[i], 20, "%s-%d", "thread", i);
//         // 创建线程                    回调函数        回调函数的参数，直接强转成(void*)就行
//         pthread_create(tid + i, nullptr, threadRoutine, (void*)name[i]);

//         cout << "=============================" << endl;
//         sleep(1);
//     }

//     int cnt = 0;
// 	// 主线程不断运行
//     while(1)
//     {
//         // 这里让主线程睡3s再打印 
//         sleep(3);
//         cout << "mainThread is running, pid:: " << getpid() << endl;
//         if(cnt++ == 3) break;
//     }

//     for(int i = 0; i < n; ++i)
//     {
//         free(name[i]);
//     }

//     return 0;
// }


// // 回调函数的方法
// void* threadRoutine(void* arg)
// {

// 	// thread1 不断运行
//     while(1)
//     {
//         cout << (char*)arg << " is running, pid:: " << getpid() << endl;
//         sleep(1);
//     }
// }

// int main()
// {
// 	// 线程的id
//     pthread_t tid;
//     // 创建线程                     回调函数          回调函数的参数，直接强转成(void*)就行
//     pthread_create(&tid, nullptr, threadRoutine, (void*)"thread_1");

// 	// 主线程不断运行
//     while(1)
//     {
//         cout << "mainThread is running, pid:: " << getpid() << endl;
//         // 这里让主线程睡3s再打印 
//         sleep(3);
//     }

//     return 0;
// }
